Tidyverse: PURRR

Librerias que se utilizan en esta clase:

library(tidyverse)
library(openxlsx)
library(ggthemes)
library(fs)

Basado en los tutoriales de PURRR de Jenny Bryan y el capítulo Iteration del libro R for Data Science de Garrett Grolemund y Hadley Wickham

PURRR

PURRR es una librería en R que contiene funciones y métodos de programación funcional dentro del entorno de tidyverse.

MAP

MAP es una función para aplicar una función a cada elemento de una estructura de datos como una lista o vector. El funcionamiento de map consiste en recorrer (“loopear”) la estructura aplicando la función a cada elemento y guardando los resultados. De esta manera podemos reemplazar los loops por una forma más legible y clara de código.

La función map toma como argumentos:

• .x: un vector o lista input

• .f: una función para aplicar

map(VECTOR_O_LIST_INPUT, FUNCTION_A_APLICAR, OTROS_OPCIONALES)

Veamos un ejemplo con un vector numérico

# Aplicamos la función log10 sobre un vector
map(.x = c(10,100,1000), .f=log10)

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

Map: tipos específicos

Veamos que el resultado de map es una lista. Si sabemos cuál es el tipo de dato de nuestros resultados podemos usar variaciones de map que explicitan el tipo de dato y devuelven los resultados en un vector. Algunas de ellas son:

• map_lgl() devuelve un vector de booleanos

• map_dbl() devuelve un vector numérico

• map_chr() devuelve un vector de strings

Volvamos a ver nuestro ejemplo usando map_dbl

map_dbl(.x = c(10,100,1000), .f=log10)

[1] 1 2 3

Map: funciones

Se pueden aplicar funciones de R base o de las librerías como así también funciones definidas por el usuario. Muchas veces no es necesario definir una función de antemano, sino que podemos usar funciones anónimas o funciones lambda.

Funciones anónimas

La función se define en una única linea.

Ejemplo numérico

Por ejemplo, calculamos una función cuadrática para un vector numérico que va del 1 al 10.

# Calculamos una función cuadrática para el vector
map_dbl(.x = c(1:10), .f = function(x) x^2+1)

 [1]   2   5  10  17  26  37  50  65  82 101

Ejemplo con strings

A partir de un vector de strings queremos contar la cantidad de letras “A” en cada elemento. Para eso combinamos las funciones str_to_upper y str_count.

map_dbl(.x = c("papas FRITAS", "batatas HERVIDAS", "boniato AL HORNO"),
        .f = function(x) str_count(string = str_to_upper(x), pattern = "A"))

[1] 3 4 2

Funciones lambda

Son una forma aún más concisa de declarar funciones, aunque pueden ser más limitadas. Las variables se declaran como .x

# Calculamos otra función cuadrática para el vector
map_dbl(.x = c(1:10), .f =  ~.x^2 - .x)

 [1]  0  2  6 12 20 30 42 56 72 90

Map: Múltiples argumentos

Usamos map2 cuando queremos aplicar una función sobre dos listas o vectores:

• map2(.x, .y, .f, …)
• map2(INPUT_UNO, INPUT_DOS, FUNCTION_A_APLICAR, OTROS_OPCIONALES)

Ejemplo numérico

Veamos un ejemplo para generar observaciones de distribuciones normales a partir de los vectores de mu y sigma (este es el ejemplo del libro R for Data Science).

La funcion rnorm sirve para generar muestras aleatorias de distribución normal con media igual a mu y desviación estándar igual a sigma, donde n indica la cantidad de observaciones a generar.

# Vector de mu = medias
mu = c(0, 3, -5, 2.1)
# Vector de sigma = desvíos estándar
sigma = c(1, 0.5, 5, 0.01)
# Generamos 10 observaciones a partir de nuestros vectores
map2(.x = mu, .y = sigma, .f= rnorm, n = 10)

[[1]]
 [1]  0.9945465  0.8976740  1.2695762 -1.4685437  0.5199419  0.1595166
 [7] -0.3307085  1.5434118  0.3516043 -1.2951256

[[2]]
 [1] 3.185547 3.058735 3.495075 2.169947 2.559699 2.182306 2.722014
 [8] 2.086243 2.703892 2.668012

[[3]]
 [1]   7.126446   1.941306 -10.618847  -1.310431  -6.701077  -9.364052
 [7]  -3.503014 -10.254412  -4.606006 -13.314767

[[4]]
 [1] 2.100392 2.111527 2.092098 2.113321 2.085242 2.116517 2.098858
 [8] 2.076954 2.110509 2.096334

Ejemplo con strings

Ahora veamos con un ejemplo para crear una lista de compras.

# Vectores
kilos = c(10, 1, 6, 8, 3)
verduras =  c("papa", "batata", "zapallo", "boniato", "zanahoria")

map2_chr(.x = verduras, .y =kilos, .f = function(x,y) str_c(str_to_title(x),y, sep=": "))

[1] "Papa: 10"     "Batata: 1"    "Zapallo: 6"   "Boniato: 8"  
[5] "Zanahoria: 3"

Usamos pmap cuando queremos aplicar una función sobre una lista de argumentos:

• pmap(.l, .f, …)
• pmap(VECTOR_O_LIST_DE_INPUTS, FUNCTION_A_APLICAR, OTROS_OPCIONALES)

Volvamos al ejemplo para generar observaciones de distribuciones normales a partir de los vectores de mu y sigma, pero ahora incorporamos la cantidad de observaciones como un argumento adicional (este ejemplo también es del libro R for Data Science).

# Vector de mu
mu = c(0, 3, -5, 2.1)
# Vector de sigma
sigma = c(1, 0.5, 5, 0.01)
# Vector de cantidad de observaciones 
n = c(1:4)
# Lista de argumentos
argumentos <- list(n, mu, sigma)
# Generamos las observaciones a partir de nuestra lista de parámetros
pmap(.l = argumentos, .f = rnorm)

[[1]]
[1] 0.7342365

[[2]]
[1] 3.273093 3.725330

[[3]]
[1] -7.151900  1.036900 -3.445161

[[4]]
[1] 2.110439 2.103634 2.100693 2.098944

PURRR: Dataframes y modelos

Dataframes

Las funciones de PURRR se pueden utilizar para realizar operaciones sobre dataframes. La sintaxis que vamos a utilizar es:

map(dataframe, función)

De esta manera vamos a estar aplicando la función sobre todas las columnas del dataframe. Veamos un ejemplo usando nuestra encuesta de sueldos del sector IT limpia.

# cargamos el dataset
encuesta_sueldos_limpia = read_csv("../Fuentes/encuesta_ds_final.csv")

Missing column names filled in: 'X1' [1]Parsed with column specification:
cols(
  X1 = col_double(),
  edad = col_double(),
  anos_de_experiencia = col_double(),
  anos_en_la_empresa_actual = col_double(),
  anos_en_el_puesto_actual = col_double(),
  trabajo_de = col_character(),
  salario_bruto = col_double(),
  salario_neto = col_double(),
  sueldo_dolarizado = col_logical()
)

encuesta_sueldos_limpia %>%
  # creamos variable perfil BI/DA vs DS/DI
  mutate(perfil = case_when(trabajo_de == "BI Analyst / Data Analyst" ~ "BI/DA", TRUE ~ "DS/DE"))

Comencemos analizando la cantidad de valores distintos para cada columna. Para ello usamos la función n_distinct.

map(encuesta_sueldos_limpia, n_distinct)

$X1
[1] 244

$edad
[1] 31

$anos_de_experiencia
[1] 25

$anos_en_la_empresa_actual
[1] 17

$anos_en_el_puesto_actual
[1] 13

$trabajo_de
[1] 2

$salario_bruto
[1] 116

$salario_neto
[1] 115

$sueldo_dolarizado
[1] 1

Usando la función str() se puede consultar de forma compacta la estructura interna de un objeto R. Es especialmente adecuado para mostrar de forma compacta el contenido (abreviado) de listas.

map(encuesta_sueldos_limpia, n_distinct) %>%
  str() # Agregamos str para que la salida luzca mejor

List of 9
 $ X1                       : int 244
 $ edad                     : int 31
 $ anos_de_experiencia      : int 25
 $ anos_en_la_empresa_actual: int 17
 $ anos_en_el_puesto_actual : int 13
 $ trabajo_de               : int 2
 $ salario_bruto            : int 116
 $ salario_neto             : int 115
 $ sueldo_dolarizado        : int 1

Ahora calculamos el promedio sobre las columnas numéricas.

encuesta_sueldos_limpia %>% 
  select_if(is.numeric) %>% 
  map(mean) %>% 
  str()

List of 7
 $ X1                       : num 122
 $ edad                     : num 30.6
 $ anos_de_experiencia      : num 6.01
 $ anos_en_la_empresa_actual: num 2.7
 $ anos_en_el_puesto_actual : num 2.15
 $ salario_bruto            : num 122656
 $ salario_neto             : num 62141

Calculamos la mediana sobre las columnas numéricas. Sabiendo que el resultado de la función es un número podemos usar directamente la función map_dbl.

# usando map_dbl 
encuesta_sueldos_limpia %>% 
  select_if(is.numeric) %>% 
  map_dbl(median)

                       X1                      edad 
                    122.5                      30.0 
      anos_de_experiencia anos_en_la_empresa_actual 
                      4.0                       1.0 
 anos_en_el_puesto_actual             salario_bruto 
                      1.0                   75000.0 
             salario_neto 
                  60000.0 

Recordemos que esta función devuelve un vector numérico no una lista como en el caso anterior, por eso no usamos la función str() para ver el resultado en forma compacta.

Modelos

Podemos usar la función map para calcular distintos modelos modelos. Por ejemplo, calculemos un modelo distinto según el perfil (DA y DS).

modelos_por_perfil = encuesta_sueldos_limpia %>% 
                        # separamos el dataset según perfil
                        split(.$perfil) %>% 
                        # creamos un modelo para cada perfil  
                        map(~lm(salario_neto ~ edad, data = .))

El resultado de esto es una lista con los dos modelos. Analicemos los elementos de cada uno utilizando la función tidy() de la librería broom.

modelos_por_perfil %>% map(broom::tidy)

$`BI/DA`

$`DS/DE`

NA

Evaluemos ahora la capacidad explicativa de los modelos. Para ello, comparamos el \(R^2\) de cada uno (en este caso como son modelos simples podemos utilizar esta métrica).

modelos_por_perfil %>% 
  map(broom::glance) %>% 
  map_dbl("r.squared")

    BI/DA     DS/DE 
0.1568223 0.1293064 

Mientras el modelo de edad para los perfiles BI/DA logra explicar el 15.6% de la variabilidad del fenómeno, el modelo de edad para los DS/DE logra captar un porcentaje menor de la variabilidad (12,9%).

Ejemplo: Iterando en la EPH

Lo primero que necesitamos es definir un vector o lista sobre el que iterar.

Por ejemplo, podemos armar un vector con los path a las bases individuales, con el comando fs::dir_ls. Se le especifica el path donde buscar los archivos y en este caso una expresion regular regexp para que devuelva aquellos archivos que coinciden con la misma.

# Buscamos en el path aquellos aquellos archivos que matchean a la expresion regular
bases_individuales_path <- dir_ls(path = '../Fuentes/', regexp = 'usu_individual_T')
bases_individuales_path

../Fuentes/usu_individual_T119.txt ../Fuentes/usu_individual_T120.txt 
../Fuentes/usu_individual_T219.txt ../Fuentes/usu_individual_T319.txt 
../Fuentes/usu_individual_T419.txt 

Luego, como en la función que usamos para leer las bases definimos muchos parámetros, nos podemos armar una función wrapper que sólo necesite un parámetro y simplifique la escritura del map.

# Leer la base de EPH tomando como argumento el file_path
leer_base_eph <- function(path) {
  # Lectura de archivos
  read.table(path, sep = ";", dec = ",", header = TRUE, fill = TRUE) %>%
  # Seleccionamos variables de interés
  select(ANO4, TRIMESTRE, REGION, P21, CH04, CH06)
}

Creamos una tabla que incluya los paths de cada base en una columna y los dataframes anidados correspondientes a cada base en otra.

El resultado es un dataframe donde la columna base tiene en cada fila el dataframe con la base de la EPH de ese período. Esto es lo que llamamos un nested DF o dataframe anidado.

Si queremos abrir (“desanidar”) estos dataframes anidados usamos el comando unnest().

# Desanidamos el dataframe
bases_df <- bases_df %>% unnest()
bases_df

¿Qué pasa si los dataframes que tenemos anidados no tienen la misma cantidad de columnas?

Esto mismo lo podemos usar para fragmentar el dataset por alguna variable, con la funcion group_by()

¿ De qué sirve todo esto?

No todo en la vida es un Dataframe. Hay estucturas de datos que no se pueden normalizar a filas y columnas. En esos casos recurríamos tradicionalmente a los loops. Con MAP podemos tener los elementos agrupados en un sólo objeto y aún conservar sus formas diferentes.

Ejemplo. Regresión lineal simple

Planteamos un modelo para explicar el ingreso (P21 en nuestra base) en función de la edad (CH06 en la base).

\[ Ingreso = \beta_0 + \beta_1*Edad \] Calculamos una regresion lineal sobre el dataset que contiene todas las bases de EPH.

(al final de la clase podemos charlar sobre los resultados)

De forma Tidy, la librería broom nos da los resultados sobre los coeficientes en un DF.

```r
```r
bases_df_lm <- bases_df %>% 
  # Agrupamos por region
  group_by(REGION) %>%
  # Anidamos
  nest() %>% 
  # Creamos una columna que tenga el dataframe como resultado de la funcion
  mutate(lm = map(data,fun))

bases_df_lm

# Desanidamos por la variable lm
bases_df_lm %>% 
  unnest(lm)

Si lo queremos hacer por género, veamos cómo podemos hacerlo usando MAP.

Usando MAP

Primero armamos una funcion que simplifica el código y nos devuelve la información de los coeficientes del modelo lineal calculado sobre el dataframe base.

fun <- function(base, grupo){broom::tidy(lm(P21~CH06, data = base))}

Calculamos la regresión lineal para cada grupo. En este caso elegimos género, pero podría haber sido por región también u otra variable de interés.

Obtenemos como resultado un data frame con los dos modelos anidados. Veamos los resultados del modelo, desanidando la variable lm.

# Desanidamos por la variable lm
bases_df_lm %>% 
  unnest(lm)

me quedé acá - falta actualizar WALK

Walk

Las funciones Walk tienen la misma forma que los map, pero se usan cuando lo que queremos iterar no genera una salida, sino que nos interesan los efectos secundarios que generan.

map2(.x = ABC_123$Letras,.y = ABC_123$Num,.f = funcion_prueba)[1:3]

Error in as_mapper(.f, ...) : objeto 'funcion_prueba' no encontrado

```r
walk2(.x = ABC_123$Letras,.y = ABC_123$Num,.f = funcion_prueba)

<!-- rnb-source-end -->

<!-- rnb-chunk-end -->


<!-- rnb-text-begin -->


Notemos que `walk2` no devolvió un resultado


<!-- rnb-text-end -->


<!-- rnb-chunk-begin -->


<!-- rnb-source-begin eyJkYXRhIjoiYGBgclxuYGBgclxuIyBmdW5jaW9uIHBhcmEgaW1wcmltaXJcbmltcHJpbWlyX3NhbGlkYSA8LSBmdW5jdGlvbih4LHkpe1xuICBwcmludChmdW5jaW9uX3BydWViYSh4LHkpKVxufVxuXG4jIE1hcFxubWFwMihBQkNfMTIzJExldHJhcyxBQkNfMTIzJE51bSxpbXByaW1pcl9zYWxpZGEpXG5gYGBcbmBgYCJ9 -->

```r
```r
# funcion para imprimir
imprimir_salida <- function(x,y){
  print(funcion_prueba(x,y))
}

# Map
map2(ABC_123$Letras,ABC_123$Num,imprimir_salida)

<!-- rnb-source-end -->

<!-- rnb-chunk-end -->


<!-- rnb-text-begin -->



<!-- rnb-text-end -->


<!-- rnb-chunk-begin -->


<!-- rnb-source-begin eyJkYXRhIjoiYGBgclxuYGBgclxuIyBXYWxrXG53YWxrMihBQkNfMTIzJExldHJhcyxBQkNfMTIzJE51bSxpbXByaW1pcl9zYWxpZGEpXG5cbmBgYFxuYGBgIn0= -->

```r
```r
# Walk
walk2(ABC_123$Letras,ABC_123$Num,imprimir_salida)

```

Eso que vemos es el efecto secundario dentro de la función (imprimir)

Discusión.

¿Cuándo usar estas herramientas?

En el curso hemos visto diferentes técnicas para manipulación de datos. En particular, la librería dplyr nos permitía fácilmente modificar y crear nuevas variables, agrupando. ¿Cuando usamos dplyr y cuando usamos purrr?

• Si trabajamos sobre un DF simple, sin variables anidadas (lo que conocíamos hasta hoy) podemos usar dplyr

• Si queremos trabajar con DF anidados, con cosas que no son DF, o si el resultado de la operación que vamos a realizar a nivel archivo es algo distinto a un valor único, nos conviene usar map y purrr.

• Las funciones walk son útiles por ejemplo para escribir archivos en disco de forma iterativa. Algo que no genera una salida.